﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Linq.SqlClient;
using System.Reflection;
using System.Data.SqlClient;

namespace BussinesCosea
{
    public enum TipoGuardado { NuevoRegistro = 1, ActualizaRegistro = 2 };
    
    /// <summary>
    /// Clase para manejo de la capa de negocio de el Sistema de Cosea Directos.
    /// </summary>
    public partial class CoseaDirectos : IDisposable
    {

        #region Variables Privadas

        private string _cadenaConexion = "";
        private bdCoseaDirectosDataContext db;
        private Usuario _usuarioFirmado;
        
        #endregion

        #region Propiedades

        public string CadenaConexion
        {
            get { return _cadenaConexion; }
            set { _cadenaConexion = value; }            
        }

        public Usuario UsuarioFirmado
        {
            get { return _usuarioFirmado; }
            set { _usuarioFirmado = value; }
        }

        #endregion

        #region Constructor

        public CoseaDirectos(string cadenaConexion)
        {
            this._cadenaConexion = cadenaConexion;
        }

        public CoseaDirectos(string cadenaConexion, Usuario usuarioFirmado)
        {
            this._cadenaConexion = cadenaConexion;
            this._usuarioFirmado = usuarioFirmado;
        }

        void IDisposable.Dispose()
        {
            db = null;
        }

        #endregion

        #region Métodos Públicos


        #region Usuarios


        public Usuario BuscaUsuario(string nombre)
        {
            Usuario usu = new Usuario();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                usu = db.Usuarios.Single(c => c.Nombre == nombre);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al BuscaUsuario " + ex.Message);
            }

            return usu;
        }


        #endregion


        #region Cliente

        public List<Cliente> ObtenClientes()
        {
            List<Cliente> res = new List<Cliente>();

            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                var ctes = (from cte in db.Clientes select cte);
                res = ctes.ToList<Cliente>();
            }
            catch (Exception ex)
            {
                throw new Exception("Error en ObtenClientes: " + ex.Message);
            }

            return res;
        }

        public Cliente ObtenCliente(int idCliente)
        {
            Cliente cte = new Cliente();

            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                cte = db.Clientes.Single(c => c.IdCliente == idCliente);
            }
            catch (Exception ex)
            {
                throw new Exception("Error al ObtenerCliente: " + ex.Message);
            }
            finally
            {
                db = null;
            }

            return cte;
        }


        public void GuardaCliente(Cliente cte)
        {
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                db.Clientes.InsertOnSubmit(cte);
                db.SubmitChanges();
                
            }
            catch (Exception ex)
            {
                throw new Exception("Error en GuardaCliente: " + ex.Message);
            }
            finally
            {
                db = null;
            }
            
        }

        public void ActualizaCliente(Cliente cte)
        {
            Cliente ct = new Cliente();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                ct = db.Clientes.Single(c => c.IdCliente == cte.IdCliente);
                ct.RazonSocial = cte.RazonSocial;
                ct.Rfc = cte.Rfc;
                ct.Giro = cte.Giro;
                ct.Direccion = cte.Direccion;
                ct.Colonia = cte.Colonia;
                ct.Municipio = cte.Municipio;
                ct.Estado = cte.Estado;
                ct.Telefono1 = cte.Telefono1;
                ct.Telefono2 = cte.Telefono2;
                ct.Contacto1 = cte.Contacto1;
                ct.Contacto2 = cte.Contacto2;
                ct.email = cte.email;
                ct.Comentarios = cte.Comentarios;
                ct.Cp = cte.Cp;
                db.SubmitChanges();
            }
            catch (Exception ex)
            {
                throw new Exception("Error al ActualizaCliente: " + ex.Message);
            }
            finally
            {
                db = null;
            }
        }

        public void EliminaCliente(Cliente cte)
        {
            Cliente ct = new Cliente();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                ct = db.Clientes.Single(c => c.IdCliente == cte.IdCliente);
                db.Clientes.DeleteOnSubmit(ct);
                db.SubmitChanges();
            }
            catch (Exception ex)
            {
                throw new Exception("Error al EliminaCliente: " + ex.Message);
            }
            finally
            {
                db = null;
            }
        }

        #endregion

        #region Empresa

        public List<Empresa>ObtenEmpresas()
        {
            List<Empresa> res = new List<Empresa>();

            try
            {                               
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                var emps = (from emp in db.Empresas select emp);
                res = emps.ToList<Empresa>();                             
            }
            catch (Exception ex)
            {                
                throw new Exception ("Error en ObtenEmpresas: " + ex.Message);
            }

            return res;
        }


        public Empresa ObtenEmpresa(int idEmpresa)
        {
            Empresa emp = new Empresa();

            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                emp = db.Empresas.Single(c => c.IdEmpresa == idEmpresa);
            }
            catch (Exception ex)
            {
                throw new Exception("Error al ObtenEmpresa: " + ex.Message);
            }
            finally
            {
                db = null;
            }

            return emp;
        }

        public void GuardaEmpresa(Empresa empresa)
        {
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                db.Empresas.InsertOnSubmit(empresa);
                db.SubmitChanges();

            }
            catch (Exception ex)
            {
                throw new Exception("Error en GuardaEmpresa: " + ex.Message);
            }
            finally
            {
                db = null;
            }

        }

        public void ActualizaEmpresa(Empresa empresa)
        {
            
            Empresa em = new Empresa();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                em = db.Empresas.Single(c => c.IdEmpresa == empresa.IdEmpresa);
                em.Nombre = empresa.Nombre;
                em.Direccion = empresa.Direccion;
                em.Telefono1 = empresa.Telefono1;
                em.Telefono2 = empresa.Telefono2;
                em.Representante1 = empresa.Representante1;
                em.Representante2 = empresa.Representante2;
                em.Representante3 = empresa.Representante3;
                em.NumeroEscritura = empresa.NumeroEscritura;
                em.Notario = empresa.Notario;
                em.Ciudad = empresa.Ciudad;
                em.RegistroPublicoPropiedad = empresa.RegistroPublicoPropiedad;
                em.FechaAlta = empresa.FechaAlta;
                em.Serie = empresa.Serie;
                em.RFC = empresa.RFC;

                db.SubmitChanges();
            }
            catch (Exception ex)
            {
                throw new Exception("Error al ActualizaEmpresa: " + ex.Message);
            }
            finally
            {
                db = null;
            }
        }


        public void EliminaEmpresa(Empresa empresa)
        {            
            Empresa em = new Empresa();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                em = db.Empresas.Single(c => c.IdEmpresa == empresa.IdEmpresa);
                db.Empresas.DeleteOnSubmit(em);
                db.SubmitChanges();
            }
            catch (Exception ex)
            {
                throw new Exception("Error al EliminaEmpresa: " + ex.Message);
            }
            finally
            {
                db = null;
            }
        }

        #endregion

        #region Puesto

        public List<Puesto> ObtenPuestos()
        {
            List<Puesto> res = new List<Puesto>();
            
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                var psts = (from pst in db.Puestos select pst);
                res = psts.ToList<Puesto>();                
            }
            catch (Exception ex)
            {
                throw new Exception("Error en ObtenPuestos: " + ex.Message);
            }

            return res;
        }

        public Puesto ObtenPuesto(int idPuesto)
        {
            Puesto pst = new Puesto();

            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                pst = db.Puestos.Single(c => c.IdPuesto == idPuesto);
            }
            catch (Exception ex)
            {
                throw new Exception("Error al ObtenerCliente: " + ex.Message);
            }
            finally
            {
                db = null;
            }

            return pst;
        }



        public void GuardaPuesto(Puesto pst)
        {
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                db.Puestos.InsertOnSubmit(pst);
                db.SubmitChanges();

            }
            catch (Exception ex)
            {
                throw new Exception("Error en GuardaPuesto: " + ex.Message);
            }
            finally
            {
                db = null;
            }

        }

        public void ActualizaPuesto(Puesto pst)
        {            
            Puesto ps = new Puesto();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                ps = db.Puestos.Single(c => c.IdPuesto == pst.IdPuesto);
                ps.Puesto1 = pst.Puesto1;
                db.SubmitChanges();
            }
            catch (Exception ex)
            {
                throw new Exception("Error al ActualizaPuesto: " + ex.Message);
            }
            finally
            {
                db = null;
            }
        }


        public void EliminaPuesto(Puesto pst)
        {            
            Puesto ps = new Puesto();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                ps = db.Puestos.Single(c => c.IdPuesto == pst.IdPuesto);
                db.Puestos.DeleteOnSubmit(ps);
                db.SubmitChanges();
            }
            catch (SqlException)
            {
                throw new Exception("No se puden eliminar registros ya utilizados");
            }    
            catch (Exception ex)
            {
                throw new Exception("Error al EliminaPuesto: " + ex.Message);
            }
            finally
            {
                db = null;
            }
        }

        #endregion

        #region TipoContrato

        public List<TipoContrato> ObtenTipoContrato()
        {
            List<TipoContrato> res = new List<TipoContrato>();

            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                var tpcts = (from tc in db.TipoContratos select tc);
                res = tpcts.ToList<TipoContrato>();


            }
            catch (Exception ex)
            {
                throw new Exception("Error en ObtenTipoContrato: " + ex.Message);
            }

            return res;
        }


        #endregion

        #region EstadoEmpleado

        public List<EstadosEmpleado> ObtenEstadoEmpleado()
        {
            List<EstadosEmpleado> res = new List<EstadosEmpleado>();

            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                var tpcts = (from tc in db.EstadosEmpleados select tc);
                res = tpcts.ToList<EstadosEmpleado>();
            }
            catch (Exception ex)
            {
                throw new Exception("Error en ObtenEstadoEmpleado: " + ex.Message);
            }

            return res;
        }

        #endregion

        #region RazonesEmpleado

        public List<RazonesEmpleado> ObtenRazonesEmpleado()
        {
            List<RazonesEmpleado> res = new List<RazonesEmpleado>();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                var tpcts = (from tc in db.RazonesEmpleados select tc);
                res = tpcts.ToList<RazonesEmpleado>();
            }
            catch (Exception ex)
            {
                throw new Exception("Error en ObtenRazonesEmpleado: " + ex.Message);
            }

            return res;
        }

        public void GuardaRazones(RazonesEmpleado rzn)
        {
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                db.RazonesEmpleados.InsertOnSubmit(rzn);
                db.SubmitChanges();

            }
            catch (Exception ex)
            {
                throw new Exception("Error en GuardaRazones: " + ex.Message);
            }
            finally
            {
                db = null;
            }

        }

        public void ActualizaRazones(RazonesEmpleado rzn)
        {
            RazonesEmpleado rz = new RazonesEmpleado();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                rz = db.RazonesEmpleados.Single(c => c.IdRazon == rzn.IdRazon);
                rz.Descripcion = rzn.Descripcion;
                db.SubmitChanges();
            }
            catch (Exception ex)
            {
                throw new Exception("Error al ActualizaRazones: " + ex.Message);
            }
            finally
            {
                db = null;
            }
        }


        public void EliminaRazones(RazonesEmpleado rzn)
        {
            RazonesEmpleado rz = new RazonesEmpleado();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                rz = db.RazonesEmpleados.Single(c => c.IdRazon == rzn.IdRazon);
                db.RazonesEmpleados.DeleteOnSubmit(rz);
                db.SubmitChanges();
            }
            catch (Exception ex)
            {
                throw new Exception("Error al EliminaRazones: " + ex.Message);
            }
            finally
            {
                db = null;
            }
        }

        #endregion

        #region TipoIncapacidades


        public List<TipoIncapacidade> ObtenTipoIncapacidades()
        {
            List<TipoIncapacidade> res = new List<TipoIncapacidade>();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                var tpcts = (from tc in db.TipoIncapacidades select tc);
                res = tpcts.ToList<TipoIncapacidade>();
            }
            catch (Exception ex)
            {
                throw new Exception("Error en ObtenTipoIncapacidades: " + ex.Message);
            }

            return res;
        }

        public void GuardaTipoIncapacidades(TipoIncapacidade tin)
        {
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                db.TipoIncapacidades.InsertOnSubmit(tin);
                db.SubmitChanges();

            }
            catch (Exception ex)
            {
                throw new Exception("Error en GuardaTipoIncapacidades: " + ex.Message);
            }
            finally
            {
                db = null;
            }

        }

        public void ActualizaTipoIncapacidades(TipoIncapacidade tin)
        {
            TipoIncapacidade ti = new TipoIncapacidade();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                ti = db.TipoIncapacidades.Single(c => c.IdTipoIncapacidad == tin.IdTipoIncapacidad);
                ti.Descripcion = tin.Descripcion;
                db.SubmitChanges();
            }
            catch (Exception ex)
            {
                throw new Exception("Error al ActualizaTipoIncapacidades: " + ex.Message);
            }
            finally
            {
                db = null;
            }
        }


        public void EliminaTipoIncapacidades(TipoIncapacidade tin)
        {
            TipoIncapacidade ti = new TipoIncapacidade();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                ti = db.TipoIncapacidades.Single(c => c.IdTipoIncapacidad == tin.IdTipoIncapacidad);
                db.TipoIncapacidades.DeleteOnSubmit(ti);
                db.SubmitChanges();
            }
            catch (Exception ex)
            {
                throw new Exception("Error al EliminaTipoIncapacidades: " + ex.Message);
            }
            finally
            {
                db = null;
            }
        }


        #endregion

        #region CasosEmpleado

        public List<CasosEmpleado> ObtenCasosEmpleado()
        {
            List<CasosEmpleado> res = new List<CasosEmpleado>();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                var tpcts = (from tc in db.CasosEmpleados select tc);
                res = tpcts.ToList<CasosEmpleado>();
            }
            catch (Exception ex)
            {
                throw new Exception("Error en ObtenCasosEmpleado: " + ex.Message);
            }

            return res;
        }

        public void GuardaCasosEmpleado(CasosEmpleado cae)
        {
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                db.CasosEmpleados.InsertOnSubmit(cae);
                db.SubmitChanges();

            }
            catch (Exception ex)
            {
                throw new Exception("Error en GuardaCasosEmpleado: " + ex.Message);
            }
            finally
            {
                db = null;
            }

        }

        public void ActualizaCasosEmpleado(CasosEmpleado cae)
        {
            CasosEmpleado ca = new CasosEmpleado();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                ca = db.CasosEmpleados.Single(c => c.IdCaso== cae.IdCaso);
                ca.Descripcion = cae.Descripcion;
                db.SubmitChanges();
            }
            catch (Exception ex)
            {
                throw new Exception("Error al ActualizaCasosEmpleado: " + ex.Message);
            }
            finally
            {
                db = null;
            }
        }


        public void EliminaCasosEmpleado(CasosEmpleado cae)
        {
            CasosEmpleado ca = new CasosEmpleado();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                ca = db.CasosEmpleados.Single(c => c.IdCaso == cae.IdCaso);
                db.CasosEmpleados.DeleteOnSubmit(ca);
                db.SubmitChanges();
            }
            catch (Exception ex)
            {
                throw new Exception("Error al EliminaCasosEmpleado: " + ex.Message);
            }
            finally
            {
                db = null;
            }
        }


        #endregion

        public List<BajasEmpleado> ObtenBajasEmpleado()
        {
            List<BajasEmpleado> res = new List<BajasEmpleado>();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                var tpcts = (from tc in db.BajasEmpleados select tc);
                res = tpcts.ToList<BajasEmpleado>();
            }
            catch (Exception ex)
            {
                throw new Exception("Error en ObtenBajasEmpleado: " + ex.Message);
            }

            return res;
        }








        public List<Materiale> ObtenMateriale()
        {
            List<Materiale> res = new List<Materiale>();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                var tpcts = (from tc in db.Materiales select tc);
                res = tpcts.ToList<Materiale>();
            }
            catch (Exception ex)
            {
                throw new Exception("Error en ObtenMateriale: " + ex.Message);
            }

            return res;
        }

        #endregion

        #region varios

        public string ObtieneCurp(string strPaterno, string strMaterno, string strNombre, string strFecha, string strSexo,string strCodigoEsta)
        {
            CURPLib.CURPLib calculocurp = new CURPLib.CURPLib();
            string curp = "";
            curp = calculocurp.CURPCompleta(strPaterno, strMaterno, strNombre, strFecha, strSexo, strCodigoEsta);
            return curp;
        }

        #endregion


    }
}
